home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / basic / basfrm13.zip / BASFRM.DOC next >
Text File  |  1992-07-04  |  31KB  |  655 lines
  1.                     DavisWARE Basic Formatter Version 1.3
  2.                      (C) Copyright 1992 - James R. Davis
  3.                              All Rights Reserved!
  4.  
  5. WHY BASFRM
  6. ----------
  7.  
  8.     Well it happened again.  I got so tired of using three different programs
  9. to do the job of one program.  One of them had a pause in it (shareware
  10. version) that made it take forever to format a source file.  In addition to
  11. the long delay at the begining, it also took FOUR passes, no less, and without
  12. taking into account tabulation, or indentation.  That required the use of yet
  13. another program on the processed file, just to make it look halfway decent!
  14. Then if I wanted a cross reference of all my variables, labels, etc, I had to
  15. run yet ANOTHER program to do it.  Three different programs, for one job???
  16. Naaaa... I can do better than that!  That is what spawned BASFRM!
  17.  
  18.  
  19. WHAT BASFRM IS
  20. --------------
  21.  
  22.     Those of you who know what programs I am talking about will find this one
  23. a delightful change, and also a completed product for making your programming
  24. jobs easier and less frustrating.
  25.  
  26. What BASFRM does is this:
  27.  
  28.     It will take practically ANY ASCII basic source code and format it into
  29. a good looking, fully functional program.  It doesn't just handle Quick Basic
  30. or Power Basic source, but also GW-Basic source.  And all in, get this, THREE
  31. passes!  Not to mention that it will also generate a cross reference of all
  32. the data once it's finished if you want it to!
  33.  
  34.  
  35. IS IT FOR ME?
  36. -------------
  37.  
  38. Well, let's look at a concrete example.
  39.  
  40. You've been working on this great program.  It works, but...
  41.  
  42.   A) Your programming style, leaves much to be desired.
  43.  
  44.   B) You use un-typed variables (by un-typed I mean, you use X instead of
  45.      X% which takes up more time in processing in the long run).
  46.  
  47.   C) You use alot of DEFINT commands so you don't have to worry about your
  48.      un-typed variables.
  49.  
  50.   D) You never tabulate your commands to follow the nesting level of your
  51.      loops or conditional blocks.
  52.  
  53.   E) You tend to use a lot of colons in your source, often using 300
  54.      characters on one line making it hard to follow your program's logic.
  55.  
  56.   F) You mix your structure and spacing making it hard to follow
  57.  
  58.   G) You lose track of what variables you use, or what subroutine you last
  59.      called, producing lots of spagetti code.
  60.  
  61. If you use any, or all of the aforementioned programming no-no's, then
  62. BASFRM is for you.
  63.  
  64.  
  65. WHAT IT DOES
  66. ------------
  67.  
  68.     This program will take your source code, and then separate the
  69. commands, leaving exactly one command on each line of code.  Then, it will
  70. format your code to make it look good by indenting the commands between your
  71. loops, like FOR/NEXT blocks, WHILE/WEND loops, DO/LOOP blocks, etc.  It will
  72. then go through each command, taking the variables and basic keywords and
  73. formatting them in UPPERCASE, lowercase, or Capitalized.  Then again, if you
  74. want, it will leave them the way they are.  It will also find un-typed
  75. variables, and assign a variable type (and senses your DEFtyped variables as
  76. well!).  It will generate two different kinds of cross reference files, once
  77. it's finished, so you can track down where all your variables are used.  You
  78. can change the defaults easily by using the /I switch.  All defaults can be
  79. saved to the program, by cloning, for future use.  There's no need for a
  80. configuration file.  Included with the program is an old GW-Basic program
  81. called PC-Maze that was converted to QB/PB format using BASFRM!  PC-MAZE.OLD
  82. is the original program, and PC-MAZE.NEW is the improved version after running
  83. through just once!  Give it a try to see what actually occurs during the
  84. formatting process.  You'll be amazed at the speed!
  85.  
  86. Here's an example program before running BASFRM on it:
  87.  
  88. '$INCLUDE:'RINSTR.INC'
  89. DEFLNG A-C
  90.  
  91. FOR X=1 TO 15        'Start a loop
  92. for y=1 TO 10
  93. select case X        'Get the loop going
  94.  case 1
  95.    X=1
  96.  case 15             'make it look good
  97.    X=1
  98. end select
  99. line Input#1,a$
  100. print"'ello"         'Okay here's another
  101. NEXT X,Y
  102.  
  103. 'Now let's go for it again!
  104.  
  105. GetSome:
  106. A=RINSTR(A$,"X")
  107. call TestSub(X)
  108. if x=1 then a=1
  109. print#2,"There are"x"people here."
  110. end
  111.  
  112. SUB TestSub(X)
  113. if ThiS=ThaT then    'Test this sucker out!
  114.   EXIT SUB
  115.  end IF
  116. END SUB
  117.  
  118. Now here's what the same program looks like after running BASFRM on it:
  119.  
  120. '$INCLUDE:'RINSTR.INC'
  121. DEFLNG A-C                                     <--- Note #1a
  122.  
  123. FOR X%=1 TO 15       'Start a loop
  124.   FOR Y%=1 TO 10
  125.     SELECT CASE X%   'Get the loop going
  126.      CASE 1
  127.       X%=1
  128.      CASE 15         'make it look good
  129.       X%=1
  130.     END SELECT
  131.     LINE INPUT #1,A$
  132.     PRINT "'ello"    'Okay here's another
  133. NEXT X%,Y%           ^----------------------------- Note #2
  134.  
  135. 'Now let's go for it again!
  136.  
  137. GetSome:
  138.   A=RINSTR(A$,"X")                             <--- Note #3
  139.   CALL TestSub(X%)
  140.   IF X%=1 THEN A=1                             <--- Note #1b
  141.   PRINT #2,"There are";X%;"people here."       <--- Note #4
  142.   END
  143.  
  144. SUB TestSub(X%)
  145.   IF This%=That% THEN'Test this sucker out!
  146.     EXIT SUB
  147.   END IF
  148. END SUB
  149.  
  150.     Note #1:  Notice that at the beginning of the program we DEFtyped a series
  151.               of variables that began with the letters A through C as long
  152.               integers in Note #1a.  As you can see in note #1b, the A
  153.               variable is not touched by the unassigned variable typing
  154.               routines.  This makes your compiler happy because it won't have
  155.               to load the routines to handle them later, thus optimizing your
  156.               source code further. (This was added in version 1.3)
  157.  
  158.     Note #2:  When a embedded remark is encountered, it is stripped from the
  159.               processing, and replaced in the exact same position it was
  160.               located on the source line, unless the source line has been
  161.               expanded past the point where it originally had been placed.  In
  162.               that case, it is placed directly after the last command on the
  163.               source line.
  164.  
  165.     Note #3:  Notice that the subroutine that was called [RINSTR()] is not
  166.               mistaken for a variable, even though it is not in the source.
  167.               If an $INCLUDE statement is encountered in the first pass, then
  168.               the included file is searched for sub/fn names and excludes them
  169.               from the typing routines.  This also occurs if a CALL statement
  170.               is encountered in the second pass.
  171.  
  172.     Note #4:  If the program encounters an improper PRINT statement, even
  173.               though it is a valid command, it will correct it in the second
  174.               pass so that it is more readable and easily debugged later.
  175.  
  176.     Now if you don't see the difference this program makes on your source
  177. code, then you've got to be blind!  Notice how much easier it is to follow the
  178. loop structure, and how uniform the whole program is now.  It's easier to spot
  179. your variables, and generally makes it appear to be done by a professional!
  180.  
  181.  
  182. HOW IT WORKS
  183. ------------
  184.  
  185.   First Pass:  What occurs here is that all the labels will be grabbed for use
  186.                in separating the lines in the next pass.  It will also look in
  187.                any $INCLUDEd files for SUB or FUNCTION names so they won't be
  188.                treated as regular variables.  If an include file given does
  189.                not contain a drive and a path, the program will looks at the
  190.                environment variable BFINC.  You can set this yourself as a
  191.                default directory before invoking the program.  It must end in
  192.                a backslash (\).  (e.g.:  SET BFINC=C:\BASIC\INCLUDE\)
  193.  
  194.  
  195.   Second Pass: In this pass, most of the work is done.  What happens here is
  196.                that the IF/THEN/ELSE statments are expanded to
  197.                IF/THEN/ELSE/END IF and the source code is tabulated
  198.                occordingly.  All printed statements are corrected to proper
  199.                format in the following manner
  200.  
  201.                PRINT TAB(5)"Help"X+1  and  PRINT "Help"STRING$(14,"-")"me"
  202.  
  203.                                    becomes
  204.  
  205.                PRINT TAB(5);"Help";X+1 and PRINT "Help";STRING$(14,"-");"me"
  206.  
  207.                If you are converting a GW-Basic program over to QB/PB format,
  208.                all the labels are cross checked and standardized.  This may
  209.                not sound like much, but believe me... it's the biggest routine
  210.                in the program! <G>
  211.  
  212.  
  213.   Third Pass:  In this final pass, what occurs is that all the syntax is
  214.                checked, all the variables, SUBs, FNs, Labels, and keywords are
  215.                cased occordingly, and all 'REMarks are removed if so desired.
  216.                Your lines are either expanded the way that Quick Basic does,
  217.                or compressed taking out all those unnecessary spaces.  All
  218.                un-typed variables are typed with your default and any default
  219.                contained within the DEFtype command as well, and when
  220.                finished, you will have a completely over-hauled piece of
  221.                source code, ready to go!
  222.  
  223.   NOTE:  If you option for a cross reference file to be generated, an extra
  224.          pass will be performed on the code.
  225.  
  226.  
  227. HOW TO USE IT
  228. -------------
  229.  
  230.     This program has been through a rigorous beta testing!  I have never had a
  231. program go through as much testing as this one has, and I thank all those
  232. involved in doing so, but I cannot guarentee that ALL quirks of the language
  233. have been compensated for, but I do believe I have gotten 95% of them covered.
  234. Depending on your programming style and preference, will greatly modify this
  235. programs performance.  The sloppier and more inprecise the code you run
  236. through this program, the longer it may take to process.  Whereas the better
  237. the program you run through this program, the faster it will be.  You can more
  238. or less use this program as a gradient to test just how good your programming
  239. style is!  Another hidden feature! :)
  240.  
  241.  
  242. INSTALLATION
  243. ------------
  244.  
  245.     To begin with, you need to change the defaults, unless of course you feel
  246. comfortable with them the way they are.  The current defaults are set up
  247. thusly:
  248.  
  249.         The original file is BAKed up and kept.
  250.         The indent width in spaces is 2.
  251.         The length of hard tabs (ASCII 9) is 1 space.
  252.         The indent width for Labels, SUBs, and FN is 0.
  253.         'REMarks are placed flush left, unless they are embedded.
  254.         Source code lines are expanded.
  255.         Long lines are not continued with an underscore (_).
  256.         The ELSE, ELSEIF, and CASE commands are indented 1 space.
  257.         Basic Keyword commands are placed in UPPERcase.
  258.         Labels, SUBs, and FNs are not cased at all, and left alone.
  259.         Variables are Capitalized.
  260.         Un-typed variables are given the % (integer) declaration.
  261.  
  262.     You can change any of these defaults by using its complimentary command
  263. line switch.  You can further use the /I switch on the command line to take
  264. you to the internal default editor:
  265.  
  266.                                   BASFRM /I
  267.  
  268.     The internal default editor will look like this:
  269.  
  270.     [1] Original is (K)ept/(D)eleted                           : K
  271.     [2] Indent width in spaces (0-40)                          : 2
  272.     [3] Hard TAB [ASCII 9] width in spaces (0-40)              : 1
  273.     [4] Indent width for Labels, SUBs/FNs in spaces (0-40)     : 0
  274.     [5] 'REMarks are (F)lush left/(I)ndented/(R)emoved         : F
  275.     [6] Source code lines are (C)ompressed/(E)xpanded          : E
  276.     [7] Continue_ long lines?: (Y)es/(N)o                      : N
  277.     [8] Indent ELSE/CASE/ELSEIF Statements?: (Y)es/(N)o        : Y
  278.     [9] » Keywords Case: (U)PPER/(l)ower/(C)apitol/(N)oNe      : U
  279.     [0] » Labels, SUBs, and FNs case: (U)P/(l)ow/(C)ap/(N)oNe  : N
  280.     [A] » Variables case: (U)P/(l)ow/(C)ap/(N)oNe              : C
  281.     [B] » Unassigned Variable Type: (%,&,&&,!,#,##,None)       : % - Integer
  282.  
  283.     ------ Selections marked with » are skipped in FAST mode ------
  284.  
  285.     [C]ontinue without saving        [Q]uit Install
  286.     [D] restore Defaults             [R]egister this program
  287.     [F]AST mode, currently OFF       [S]ave settings and end.
  288.  
  289.     You change the defaults by pressing the related key within the square
  290. brackets ([]) until your choice is displayed.  Each valid choice is displayed
  291. between the parenthesis.  Each default is described below:
  292.  
  293.     [1] Original is (K)ept/(D)eleted
  294.         This default tells the program wheather or not you wish to keep the
  295.         original file in a BAK file once the program is finished formatting.
  296.         The current default is K for (K)ept.
  297.  
  298.     [2] Indent width in spaces (0-40)
  299.         This indent width is defined in spaces, not tabs.  Each time a loop is
  300.         encountered within the code, the loop will be formatted with the
  301.         following formula:  Position = Indent_Width * Current_Loop_Level.
  302.         If the current loop level is 4 levels deep, and the indent width is
  303.         set to 3 then the indentation of the command will be placed 12 spaces
  304.         from the beginning of the line.  The current setting for this default
  305.         is 2, but can be any number from 0 to 40.
  306.  
  307.     [3] Hard TAB [ASCII 9] width in spaces (0-40)
  308.         Hard tabs are produced by some text editors such as Q-EDIT that in all
  309.         actuality are tabs, but only take up 1 character within your file.
  310.         Some programmers tend to use text editors to do their programming in
  311.         and this can produce problems with this program.  So, in order to
  312.         correct that problem, I have included this default which in all
  313.         actuality, strips out all ASCII 9 characters occured and replaces them
  314.         with the number of spaces you set this default with.  If you are using
  315.         a text editor, you may wish to set this default to the size of tabs
  316.         you have set in your text editor.  This default is currently set to 1
  317.         space.
  318.  
  319.     [4] Indent width for Labels, SUBs/FNs in spaces (0-40)
  320.         The indent width for Labels, Subs, and Fns is defined with this
  321.         default.  The number of spaces you have this set to, will be the
  322.         number of spaces that will be placed in front of your Labels, Subs,
  323.         and Fns.  This is currently set to 0.
  324.  
  325.     [5] 'REMarks are (F)lush left/(I)ndented/(R)emoved
  326.         This default tells the program how you wish to handle remark lines.
  327.         They can be either Flush Left, Indented at the current indention
  328.         level, or Removed completely from the source code.  This is currently
  329.         set to make your remarks Flush Left.
  330.  
  331.     [6] Source code lines are (C)ompressed/(E)xpanded
  332.         This default tells the program how you would like you completed source
  333.         code lines to appear.  In Compressed format, all unnecessary spaces
  334.         are removed, whereas in Expanded format, spaces are placed in between
  335.         all the operators, keywords, etc, in much the same way that the Quick
  336.         Basic's IDE (Integrated Developement Environment) does whenever you
  337.         move your cursor to a new line after typing in your code.  This is
  338.         currently set to Expand all source code lines.
  339.  
  340.     [7] Continue_ long lines?: (Y)es/(N)o
  341.         This default tells the program that you wish to conitue long lines of
  342.         source code with an underscore [_] so that all your source code
  343.         appears on the screen instead of having to move your cursor over to
  344.         the end of a long line so you can see what's going on.  This is
  345.         currently set to No.
  346.  
  347.     [8] Indent ELSE/CASE/ELSEIF Statements?: (Y)es/(N)o
  348.         This default will tell the program that if it occurs any ELSE, CASE,
  349.         or ELSEIF keywords, it will place 1 space in front of it to make you
  350.         loops look more unique.  This is currently set to Yes.
  351.  
  352.     [9] » Keywords Case: (U)PPER/(l)ower/(C)apitol/(N)oNe
  353.         This default will tell the program to turn all keywords it encounters
  354.         into the case you specify.  This can be set to put all keywords in
  355.         uppercase or lowercase, capitolize the first letter of each keyword,
  356.         or leave them alone completely.  This is currently set to change
  357.         keywords into Uppercase.  Note: This is skipped if FAST mode is
  358.         utilized.
  359.  
  360.     [0] » Labels, SUBs, and FNs case: (U)P/(l)ow/(C)ap/(N)oNe
  361.         This works the same way that default 9 does, only in this case it
  362.         works on labels, sub and function names.  See default 9 above for
  363.         further info.  Currently set to None.  Note: This is skipped if FAST
  364.         mode is utilized.
  365.  
  366.     [A] » Variables case: (U)P/(l)ow/(C)ap/(N)oNe              : C
  367.         This works the same way that default 9 does, only in this case it
  368.         works on your variables.  See default 9 above for further info.
  369.         Currently set to Capitolize.  Note: This is skipped if FAST mode is
  370.         utilized.
  371.  
  372.     [B] » Unassigned Variable Type: (%,&,&&,!,#,##,None)       : % - Integer
  373.         This default tells the program that you wish to have your untyped
  374.         variables typed with the default you give it here.  The following
  375.         describes what each selection in this default means, and various
  376.         compatibility with compilers:
  377.  
  378.                Sym   Definition           Supported by
  379.                ---   ----------           ------------
  380.                 %  - Integer              Quick and PowerBASIC
  381.                 &  - Long Integer         Quick and PowerBASIC
  382.                 && - Quad Integer         PowerBASIC only
  383.                 !  - Single Precision     Quick and PowerBASIC
  384.                 #  - Double Precision     Quick and PowerBASIC
  385.                 ## - Extended Precision   PowerBASIC only
  386.  
  387.         Make sure your compiler supports the option you wish to use before
  388.         setting this default.  If it is set to None, no typing is performed on
  389.         untyped variables.  This is currently set to type untyped variables to
  390.         integer format.  Note: This is skipped if FAST mode is utilized.
  391.  
  392.     [C]ontinue without saving
  393.         By pressing [C] while at this menu, if you specified a file on the
  394.         command line along with the /I option, the program will continue to
  395.         format the file specified using the defaults the way they are set now,
  396.         without saving them at all.  This can come in handy if you wish to
  397.         change only a few of your defaults, to format a file without saving
  398.         them.
  399.  
  400.     [D] restore Defaults
  401.         By pressing [D] at anytime in this menu, all the programs original
  402.         defaults will be restored.  This can come in handy if you mess up and
  403.         want to start all over again.
  404.  
  405.     [F]AST mode, currently OFF
  406.         By pressing [F] at this menu, you will notice the current setting of
  407.         the FAST mode change from OFF to ON.  This comes in handy if you wish
  408.         to format in FAST mode on the file specified on the command line.
  409.  
  410.     [Q]uit Install
  411.         By pressing [Q] at anytime, will return you to DOS without saving any
  412.         of your settings.  Think of it as the quick abort.
  413.  
  414.     [R]egister this program
  415.         By pressing [R] you will be taken to the registration screen, which
  416.         will allow you to register your copy of this program.  This is only
  417.         useful for those who register this program.
  418.  
  419.     [S]ave settings and end.
  420.         By pressing [S] in this menu, you will save your current setting
  421.         permanently to the EXE file for future use, and return to DOS.  Once
  422.         saved the defaults you set will always be in use whenever the program
  423.         is invoked.  (IMPORTANT NOTE: The EXE file must not be PKLITEd before
  424.         you invoke this command.  Only after the defaults are saved the way
  425.         you would like them, can you PKLITE the EXE!  If the original EXE was
  426.         over 100k in size, it should not be PKLITEd, if not, UN-PKLITE before
  427.         saving your defaults.)
  428.  
  429.  
  430. OPERATION
  431. ---------
  432.  
  433.     To begin formatting a program, type the following command:
  434.  
  435.                BASFRM [*]filespec[.ext] [switch]
  436.  
  437.     Everything contained within the square brackets is optional.  Anything
  438. separated by a pipe [|] shows a selection of items that only one of which can
  439. be used.  Anytime you see a plus sign (+) it means that by using it with a
  440. switch, you will turn that feature ON.  Anytime you see a minus sign (-) it
  441. means that by using it with a switch, you will turn that feature OFF.  Here is
  442. a listing of all the available command line switches:
  443.  
  444.  *             - Placing a asterisk [*] in front of the filename tells the
  445.                  program that you wish to run in FAST mode.  This is optional.
  446.                  (See selection [F] in installation above for further info on
  447.                  FAST mode.)
  448.  
  449.  filespec      - This is the name of the file you wish to process.  The file
  450.                  must be in ASCII text.  If you wish to convert from GW-Basic,
  451.                  you must save the file using the ,A command.
  452.  
  453.  .ext          - You can include the extention, but if you omit it from the
  454.                  filename, .BAS is assumed.  This is optional.
  455.  
  456.  /XL           - By specifying this command line switch, you tell the program
  457.                  that you wish to generate a cross reference file that will be
  458.                  referenced by labels occured within the program, when the
  459.                  first three passes are finished.
  460.  
  461.  /XN           - By specifying this command line switch, you tell the program
  462.                  that you wish to generate a cross reference file that will be
  463.                  referenced by source line numbers in the program, when the
  464.                  first three passes are finished.
  465.  
  466.  /XXL          - Will tell the program to skip the first three passes and
  467.                  generate a cross reference file on the filename specified.
  468.                  If this option is selected to process a file that has not
  469.                  been formatted by this program, the results can be
  470.                  unpredictable. (See the /XL option above.)
  471.  
  472.  /XXN          - Will tell the program to skip the first three passes and
  473.                  generate a cross reference file on the filename specified.
  474.                  If this option is selected to process a file that has not
  475.                  been formatted by this program, the results can be
  476.                  unpredictable. (See the /XN option above.)
  477.  
  478.  /BAK[+|-]     - Turn the baking up of the original file ON or OFF.
  479.  
  480.  /REM[F|I|R]   - Set the 'REMark handling to place the remarks either (F)lush
  481.                  left, (I)ndented, or (R)emove them all together.
  482.  
  483.  /INDxx        - Set the indent width of your source code lines in spaces,
  484.                  where xx is a number from 0-40
  485.  
  486.  /TABxx        - Set the Hard TAB (ASCII 9) width in spaces, where xx is a
  487.                  number from 0-40.  This is the number of spaces that will
  488.                  be replacing any (ASCII 9) characters found in your code.
  489.                  Usually, most text editors default to 4,6,8 spaces.
  490.  
  491.  /LBIxx        - Set the Labels/Subs/FNs indent width in spaces, where xx is a
  492.                  number from 0-40.
  493.  
  494.  /CPR or /EXP  - Set the source code handling to either compressing (CPR) the
  495.                  source code (by taking out all the spaces) or expanding (EXP)
  496.                  the source code (puts all the spaces in between operators,
  497.                  must the way that QB's IDE does it automatically).
  498.  
  499.  /CNT[+|-]     - Set the continuing_ of lines longer then 78 characters ON or
  500.                  OFF.
  501.  
  502.  /IEL[+|-]     - Set the indenting of ELSE/ELSEIF/CASE statements one
  503.                  tabulation space more (as set with the -INDxx switch above)
  504.                  ON or OFF.
  505.  
  506.  /KEY[U|L|C|N] - Change the casing of basic keywords to (U)ppercase,
  507.                  (L)owercase, (C)apitolized, or (N)ot changed.
  508.  
  509.  /LAB[U|L|C|N] - Change the casing of Labels/Subs/FNs to (U)ppercase,
  510.                  (L)owercase, (C)apitolized, or (N)ot changed.
  511.  
  512.  /VAR[U|L|C|N] - Change the casing of Variables to (U)ppercase, (L)owercase,
  513.                  (C)apitolized, or (N)ot changed.
  514.  
  515.  /TYP[xx|N]    - Change Unassigned Variable Type where xx is %,&,&&,!,#,##, or
  516.                  (N)ot Changed. (See [B] previously under INSTALLATION for an
  517.                  explaination of what each symbol here represents.)
  518.  
  519.  
  520. THE DISPLAY
  521. -----------
  522.  
  523.     When the program is operating correctly, you will see the following
  524. display:
  525.  
  526.   Formatting filename : TEST.BAS             Backup original file: Yes
  527.   Line handling       : Expanded             Hard TAB space width: 1
  528.   Indent ELSE/CASE?   : Yes                  Width of tab spaces : 2
  529.   BASIC Keywords case : Upper case           Position of Labels  : 0
  530.   Variable case       : Capitolized          'REMark handling    : Flush Left
  531.   Labels/SUBs/FNs case: Not Changed          Continue_ long lines: No
  532.   Unassigned variables: % - Integer          Generate Cross Ref? : Yes
  533.   ------------------------[ Current Processing Status ]-----------------------
  534.   Current Pass        : 1st                  Remarks Processed   : 0
  535.   Percent Complete    : 0.00%                Lines Continued     : 0
  536.   Current Line Number : 1                    Sub/Fn's Found      : 0
  537.   New File Line Number: 0                    Keywords Found      : 0
  538.   Labels Found        : 0                    Variables Found     : 0
  539.   Labels Changed      : 0                    Opened Files Found  : 0
  540.   -------------------------[ Current Processing Time ]------------------------
  541.   Time Process Started: 12:20:37.93          Current Process Time: 12:20:39.13
  542.   ------------------------[ Current Processing Comment ]----------------------
  543.     -   Grabbing Labels and $INCLUDEd Sub/Fn's
  544.  
  545.     The display is broken up into four sections.  The first section displays
  546. what the current defaults contain.  The second section displays the current
  547. process that is taking place and what is occuring.  The third section displays
  548. the programs timer and how long the entire program will take to complete it's
  549. task.  The fourth and final section tells you what actually is occuring in the
  550. program at any particular time.  You can press ESC at any time during
  551. processing to abort the process.  Your original file will not be touched, and
  552. all work files will be deleted.
  553.  
  554.  
  555. FAST MODE AND SOURCE CODE PLUG IN'S
  556. -----------------------------------
  557.  
  558.     What occurs in FAST mode is that all variable, label, keyword, sub/fn
  559. casing, and untyped variable typing is bypassed, thus speeding up the program
  560. in it's final pass.  There are also some source code plugs that you can place
  561. directly into your source code for processing.  Take a look at the example
  562. below and read the description that follows:
  563.  
  564. FOR x%=1 to 10
  565. gosub Jump
  566. next X
  567. Jump:
  568. 'BASFRM+
  569.   PRINT "This part of the code has already been processed!"
  570.   RETURN
  571. 'BASFRM-
  572. print"Process me"
  573.  
  574. Would become:
  575.  
  576. FOR X%=1 TO 10
  577.   GOSUB Jump
  578. NEXT X%
  579. Jump:
  580. 'BASFRM+
  581.   PRINT "This part of the code has already been processed!"
  582.   RETURN
  583. 'BASFRM-
  584.   PRINT "Process me"
  585.  
  586.     By stratigically placing a 'BASFRM+ or a 'BASFRM- in already processed
  587. source code, you can skip over large chunks of code, thus speeding up the
  588. program processing.  One thing that is necessary though is that the 'BASFRM+
  589. plug must be placed after the first label in the code unless, the 'BASFRM-
  590. switch is placed before the first label.  Otherwise, unpredictable tabulations
  591. may occur.
  592.  
  593.     Here's a list of all the source code plugs:
  594.  
  595.               'BASFRM+
  596.               'BASFRM-
  597.               'BASFRM KEYCASE [UPPER|lower|Capitol|NoNe|Default]
  598.               'BASFRM LABCASE [UPPER|lower|Capitol|NoNe|Default]
  599.               'BASFRM VARCASE [UPPER|lower|Capitol|NoNe|Default]
  600.               'BASFRM VARTYPE [%|&|&&|!|#|##|None|Default]
  601.  
  602.     They should be pretty self explainitory.  By using the DEFAULT switch, you
  603. will be using the program's last saved defaults.  You don't have to type out
  604. the full switch word either, you can just use U,L,C,N, or D, except for the
  605. VARTYPE switch.  Any of these commands can be in upper, lower or mixed case in
  606. the source code (it's not picky).
  607.  
  608.  
  609. ACKNOWLEDGEMENTS
  610. ----------------
  611.  
  612.     I'd like to thanks the following individuals for they're exceptional help
  613. in finding all the little bugs and the suggestions they have given in testing
  614. this program out thoroughly:
  615.  
  616.     Dave Navarro for introducing me to PowerBASIC and all it's power.
  617.  
  618.     Lloyd Smith for all his enthusiasm and complete confidence in the success
  619.     of this program.
  620.  
  621.     Joe Negron for his exemplery work in finding bugs and his excellent
  622.     reporting of things I could never have expected!
  623.  
  624.     Alan Earnshaw for providing many suggestions that were implemented in this
  625.     program.
  626.  
  627.     Max Bernard for helping out in many ways, all of which I could not
  628.     possibly list at this time.
  629.  
  630.     Thanks to all of you, this program has become a reality!  Without your
  631. help and support, I probably would have given up long ago.
  632.  
  633.  
  634. ALL DONE
  635. --------
  636.  
  637.     This program is Shareware, meaning... IT'S NOT FREE... BUT it is not
  638. disabled in any way either.  No hidden pauses, features, or other hype like
  639. some authors so frustrating do these days.  If you find that you use this
  640. program (more then 5 times) then send for registration.
  641.  
  642.                 The registration fee for this program is $20.
  643.  
  644.     That's a very reasonable price considering all the work that I have put
  645. into this sucker!  If you would like to register this program, use the
  646. inclosed ORDER.FRM...  Read it's instructions... It should be clear enough!
  647. Shareware is a TRY-BEFORE-YOU-BUY concept that remains alive because of people
  648. like you who do register software.  If everyone didn't register, us authors
  649. would probably end up totally discouraged and completely broke! <G>  I do hope
  650. that you like this program and find it worthy of your programming tool
  651. collection.  Until the next version...
  652.  
  653.                        -=> James "The Garf!" Davis! <=-
  654.  
  655.